package com.hd.trans.utils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.media.ExifInterface;
import android.os.Environment;
import android.util.Log;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;


public class PhotoBitmapUtils {


    public static final String IMAGE_TYPE = ".jpg";


    // 防止实例化
    private PhotoBitmapUtils() {
    }

    /**
     * 获取手机可存储路径
     *
     * @param context 上下文
     * @return 手机可存储路径
     */
    private static String getPhoneRootPath(Context context) {
        // 是否有SD卡
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)
                || !Environment.isExternalStorageRemovable()) {
            // 获取SD卡根目录
            return context.getExternalCacheDir().getPath();
        } else {
            // 获取apk包下的缓存路径
            return context.getCacheDir().getPath();
        }
    }

    /**
     * 使用当前系统时间作为上传图片的名称
     *
     * @return 存储的根路径+图片名称
     */
    public static String getSourcePhotoFileName() {
        File file = new File(PhotoFileUtil.getPhotoOrigPath());
        // 判断文件是否已经存在，不存在则创建
        if (!file.exists()) {
            file.mkdirs();
        }
        // 设置图片文件名称
        String time = UUID.randomUUID().toString();
        String photoName = "/" + time + IMAGE_TYPE;
        return file + photoName;
    }

    public static String getSourcePhotoAlbumDir() {
        File file = new File(FileUtils.getAlbumDir());
        // 判断文件是否已经存在，不存在则创建
        if (!file.exists()) {
            file.mkdirs();
        }
        // 设置图片文件名称
        String time = UUID.randomUUID().toString();
        String photoName = "/" + time + IMAGE_TYPE;
        return file + photoName;
    }


//    public String getSourceFileCatch(){
//        String sourceFileCatch;
//        if (Environment.MEDIA_MOUNTED == Environment.getExternalStorageState()) {
//            return Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "ImageOCR"+ File.separator+"sourcecache";
//
//        } else {
//            return ActivityManager.currentActivity()?.filesDir.toString() + File.separator + "ImageOCR"+ File.separator+"sourcecache";
//        }
//    }

    /**
     * 保存Bitmap图片在SD卡中
     * 如果没有SD卡则存在手机中
     *
     * @param mbitmap 需要保存的Bitmap图片
     * @return 保存成功时返回图片的路径，失败时返回null
     */
    public static String saveSourcePhotoToSD(Bitmap mbitmap) {
        Log.e("yang", "start save");
        FileOutputStream outStream = null;
        String fileName = getSourcePhotoFileName();
        try {
            outStream = new FileOutputStream(fileName);
            // 把数据写入文件，100表示不压缩
            mbitmap.compress(Bitmap.CompressFormat.JPEG, 100, outStream);
            Log.e("yang", "save over");
            return fileName;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                if (outStream != null) {
                    // 记得要关闭流！
                    outStream.close();
                }
//                if (mbitmap != null) {
//                    mbitmap.recycle();
//                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static String saveSourcePhotoToAlbumDir(Bitmap mbitmap) {
        Log.e("yang", "start save");
        FileOutputStream outStream = null;
        String fileName = getSourcePhotoAlbumDir();
        try {
            outStream = new FileOutputStream(fileName);
            // 把数据写入文件，100表示不压缩
            mbitmap.compress(Bitmap.CompressFormat.JPEG, 100, outStream);
            Log.e("yang", "save over");
            outStream.flush();
        } catch (Exception e) {
            e.printStackTrace();
            fileName = null;
        } finally {
            try {
                if (outStream != null) {
                    // 记得要关闭流！
                    outStream.close();
                }
//                if (mbitmap != null) {
//                    mbitmap.recycle();
//                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return fileName;
    }

    /**
     * 使用当前系统时间作为上传图片的名称
     *
     * @return 存储的根路径+图片名称
     */
    public static String getPhotoFileName() {
        File file = new File(PhotoFileUtil.getPhotoTargetPath());
        // 判断文件是否已经存在，不存在则创建
        if (!file.exists()) {
            file.mkdirs();
        }
        // 设置图片文件名称
        String time = UUID.randomUUID().toString();
        String photoName = "/" + time + IMAGE_TYPE;
        return file + photoName;

    }

    /**
     * 保存Bitmap图片在SD卡中
     * 如果没有SD卡则存在手机中
     *
     * @param mbitmap 需要保存的Bitmap图片
     * @return 保存成功时返回图片的路径，失败时返回null
     */
    public static String savePhotoToSD(Bitmap mbitmap) {
        Log.e("yang", "start save");
        FileOutputStream outStream = null;
        String fileName = getPhotoFileName();
        try {
            outStream = new FileOutputStream(fileName);
            // 把数据写入文件，100表示不压缩
            mbitmap.compress(Bitmap.CompressFormat.JPEG, 100, outStream);
            Log.e("yang", "save over");
            return fileName;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                if (outStream != null) {
                    // 记得要关闭流！
                    outStream.close();
                }
//                if (mbitmap != null) {
//                    mbitmap.recycle();
//                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 把原图按1/10的比例压缩
     *
     * @param path 原图的路径
     * @return 压缩后的图片
     */
    public static Bitmap getCompressPhoto(String path) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = false;
        options.inSampleSize = 2;  // 图片的大小设置为原来的十分之一
        Bitmap bmp = BitmapFactory.decodeFile(path, options);
        options = null;
        return bmp;
    }

    /**
     * 处理旋转后的图片
     *
     * @param originpath 原图路径
     * @param context    上下文
     * @return 返回修复完毕后的图片路径
     */
    public static String amendRotatePhoto(String originpath, Context context) {

        // 取得图片旋转角度
        int angle = readPictureDegree(originpath);

        // 把原图压缩后得到Bitmap对象
        Bitmap bmp = getCompressPhoto(originpath);

        // 修复图片被旋转的角度
        Bitmap bitmap = rotaingImageView(angle, bmp);

        // 保存修复后的图片并返回保存后的图片路径
        return savePhotoToSD(bitmap);
    }

    /**
     * 读取照片旋转角度
     *
     * @param path 照片路径
     * @return 角度
     */
    public static int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

    /**
     * 旋转图片
     *
     * @param angle  被旋转角度
     * @param bitmap 图片对象
     * @return 旋转后的图片
     */
    public static Bitmap rotaingImageView(int angle, Bitmap bitmap) {
        Bitmap returnBm = null;
        // 根据旋转角度，生成旋转矩阵
        Matrix matrix = new Matrix();
        matrix.postRotate(angle);
        try {
            // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
            returnBm = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        } catch (OutOfMemoryError e) {
        }
        if (returnBm == null) {
            returnBm = bitmap;
        }
        if (bitmap != returnBm) {
            bitmap.recycle();
        }
        return returnBm;
    }


    /**
     * 质量压缩方法
     *
     * @param path
     * @return
     */
    public static String compressImage(String path, Context context) {

        Bitmap image = BitmapFactory.decodeFile(path);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 80;
        if (baos.toByteArray().length > 5 * 1024 * 1024) {
            options = 50;
        }

        while (baos.toByteArray().length > 3 * 1024 * 1024) { // 循环判断如果压缩后图片是否大于3M,大于继续压缩
            baos.reset(); // 重置baos即清空baos
            image.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%，把压缩后的数据存放到baos中
            options -= 20;// 每次都减少20
        }
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());// 把压缩后的数据baos存放到ByteArrayInputStream中
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
        return savePhotoToSD(bitmap);
    }

    /**
     * 将本地图片转换为 Drawable
     * @param context 上下文
     * @param file 文件路径
     * @return
     */
    public static Drawable path2Drawable(Context context, String file) {
        return path2Drawable(context, file, false);
    }
    public static Drawable path2Drawable(Context context, String file, boolean isBlur) {

        if (file == null || file.isEmpty()) {
            return null;
        }

        Drawable drawable = null;
        try {
            Bitmap bitmap;
            if(file.startsWith("example")){
                InputStream inputStream = context.getAssets().open(file);
                bitmap = BitmapFactory.decodeStream(inputStream);
            }else {
                FileInputStream fis = new FileInputStream(file);
                bitmap = BitmapFactory.decodeStream(fis);
            }
            if(bitmap != null){
                /* // 取得图片旋转角度
            int angle = readPictureDegree(file);
            Log.e("liaoyucheng","angle = "+ angle);
            // 图片旋转角度
            bitmap = rotaingImageView(angle, bitmap);*/

                if(bitmap.getWidth() > bitmap.getHeight()*1.5){
                    // 图片旋转角度
                    bitmap = rotaingImageView(90, bitmap);
                }
                if(isBlur){
                    //高斯模糊处理
                    bitmap = partiallyBlurred(bitmap, 0.2f);

                }

                drawable = new BitmapDrawable(context.getResources(), bitmap);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

        return drawable;
    }

    public static Bitmap partiallyBlurred(Bitmap bitmap, float proportion){
        if(proportion > 1) proportion =1f;
        Bitmap mBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(mBitmap);
        //裁剪
        canvas.drawBitmap(
                bitmap,
                new Rect(0, 0, mBitmap.getWidth(), (int) (mBitmap.getHeight() * proportion)),
                new Rect(0, 0, mBitmap.getWidth(), (int) (mBitmap.getHeight() * proportion)),
                new Paint()
                );
        canvas.save();
        //高斯模糊处理
        bitmap = ImageUtil.INSTANCE.blurBitmap(bitmap,16);
        //裁剪
        canvas.drawBitmap(
                bitmap,
                new Rect(0, (int) (mBitmap.getHeight() * proportion), mBitmap.getWidth(), mBitmap.getHeight()),
                new Rect(0, (int) (mBitmap.getHeight() * proportion), mBitmap.getWidth(), mBitmap.getHeight()),
                new Paint()
        );
        canvas.save();
        canvas.restore();
        return mBitmap;
    }

}
